home *** CD-ROM | disk | FTP | other *** search
/ Electronic Clipper 1995 April / Electronic Clipper 1995-04.iso / mac / PC_USERS / IDEASRC / SETUP / MPLAYER / MOVIEUTL.C < prev    next >
Text File  |  1993-04-17  |  29KB  |  692 lines
  1.  
  2. // ---------------------------------------------------------------------
  3. //
  4. // MovieUtl.c - Movie Player - QuickTime for Windows
  5. //
  6. //              Version 1.0
  7. //
  8. //              (c) 1988-1992 Apple Computer, Inc. All Rights Reserved.
  9. //
  10. // ---------------------------------------------------------------------
  11.  
  12.  
  13.  
  14. // Includes
  15. // --------
  16.    #include <Windows.H>               // Required by Windows
  17.    #include <qtw.h>                   // Interface to QuickTime
  18.    #include <qtole.h>                 // Interface to qtole dll
  19.    #include <string.h>                // Standard "C"
  20.  
  21.    #include "common.h"                // Interface to common.c
  22.  
  23.    #include "player.h"                // Interface to other *.c files
  24.    #include "player.hr"               // Defines used in *.rc files
  25.  
  26. // Constants
  27. // ---------
  28.    #define  OPTIONSPROP   "MovieOptionsProp"
  29.  
  30.  
  31. // typedefs
  32. // --------
  33.    typedef struct _tagWORKOPTIONS
  34.       {QTOLE_OPTIONSMOVIE      SaveOptions;
  35.        LPQTOLE_OPTIONSMOVIE    lpOptions;
  36.        HLOCAL                  hmem;
  37.       } WORKOPTIONS;
  38.    typedef WORKOPTIONS NEAR * NPWORKOPTIONS;
  39.  
  40.  
  41. // Exported callback functions
  42. // ----------------------------
  43.    BOOL __export CALLBACK GetOptionsDlgProc    (HWND, UINT, WPARAM, LPARAM);
  44.  
  45. // Internal Function Declarations
  46. // ------------------------------
  47.    static VOID    NEAR    SetDlgForOptions       (HWND, LPQTOLE_OPTIONSMOVIE);
  48.    static VOID    NEAR    GetCurrentDlgSettings  (HWND, LPQTOLE_OPTIONSMOVIE);
  49.    static VOID    NEAR    SaveOptionsAsDefault   (LPQTOLE_OPTIONSMOVIE);
  50.  
  51.  
  52. // Function: PlayerGetOptions - Opens the options dialog
  53. // --------------------------------------------------------------------
  54. // Parameters: HWND                    hwndParent     HWND of dialog parent
  55. //             LPQTOLE_OPTIONSMOVIE    lpOptions      -> options struct
  56. //
  57. // Returns:    LONG                    0L if OK
  58. // --------------------------------------------------------------------
  59.    BOOL FAR PlayerGetOptions( HWND hwndParent, LPQTOLE_OPTIONSMOVIE lpOptions )
  60.  
  61.      {BOOL         bChangedOptions = FALSE;
  62.       DLGPROC      lpDlgProc;
  63.  
  64.       if( lpDlgProc = (DLGPROC) MakeProcInstance
  65.                   ( (FARPROC) GetOptionsDlgProc, PlayerQueryInstance()))
  66.          {bChangedOptions = (BOOL) DialogBoxParam( PlayerQueryResources(),
  67.                                  MAKEINTRESOURCE( PLAYER_DLG_OPTIONS ),
  68.                                   hwndParent? hwndParent: GetActiveWindow(),
  69.                                                lpDlgProc, (LPARAM) lpOptions );
  70.           FreeProcInstance( (FARPROC) lpDlgProc );
  71.  
  72.              // Null hwndParent indicates that dlg was started by qtole message
  73.              // with no open movie. In this case tell QTOle.dll that dialog has
  74.              // been closed. Must do this even if options are not changed and
  75.              // must return the same pointer to lpOptions as input argument to
  76.              // this function. When qtole opens dialog for open movie, normal
  77.              // closing will updata options
  78.           if( !hwndParent )
  79.               QTOLE_ClosedOptionsDlg( PlayerQueryOleData(),
  80.                                (LPQTOLE_OPTIONS) lpOptions, bChangedOptions );
  81.          }
  82.       else
  83.          {CommonTellUser( PlayerQueryResources(),
  84.                                  PLAYER_STRING_NOMEMORY, NULL, MB_OK );
  85.          }
  86.  
  87.       return bChangedOptions;
  88.      }
  89.  
  90.  
  91. // Function: GetOptionsDlgProc - Get options dialog proc
  92. // --------------------------------------------------------------------
  93. // Parameters: As required by Microsoft Windows
  94. //
  95. // Returns:    As required by Microsoft Windows
  96. // --------------------------------------------------------------------
  97.    BOOL __export CALLBACK GetOptionsDlgProc
  98.                 ( HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam )
  99.  
  100.      {NPWORKOPTIONS           pwoWorkOptions;
  101.       HLOCAL                  hmem;
  102.       BOOL                    bOptionsChanged;
  103.       BOOL                    bChecked;
  104.       LPQTOLE_OPTIONSMOVIE    lpOptions;
  105.  
  106.       switch( message )
  107.          {case WM_INITDIALOG:
  108.              lpOptions = (LPQTOLE_OPTIONSMOVIE) lParam;
  109.  
  110.              hmem = LocalAlloc( LHND, sizeof( WORKOPTIONS ));
  111.              pwoWorkOptions = (NPWORKOPTIONS) LocalLock( hmem );
  112.              pwoWorkOptions->hmem = hmem;
  113.              pwoWorkOptions->SaveOptions = *lpOptions;
  114.              pwoWorkOptions->lpOptions   = lpOptions;
  115.  
  116.              SetProp( hdlg, OPTIONSPROP, (HANDLE) pwoWorkOptions );
  117.  
  118.              SetDlgForOptions( hdlg, pwoWorkOptions->lpOptions );
  119.  
  120.              SetDlgItemText( hdlg, EDIT_OPTIONS_CAPTION,
  121.                                         pwoWorkOptions->lpOptions->szCaption );
  122.  
  123.              return TRUE;
  124.  
  125.           case WM_COMMAND:
  126.              switch( wParam  )
  127.                 {case IDOK:
  128.                      pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  129.                      GetCurrentDlgSettings( hdlg, pwoWorkOptions->lpOptions );
  130.  
  131.                      bOptionsChanged
  132.                          = (_fmemcmp( pwoWorkOptions->lpOptions,
  133.                                        &pwoWorkOptions->SaveOptions,
  134.                                             sizeof( QTOLE_OPTIONSMOVIE )) != 0 );
  135.                      hmem = pwoWorkOptions->hmem;
  136.                      LocalUnlock( hmem );
  137.                      LocalFree( hmem );
  138.                      RemoveProp( hdlg, OPTIONSPROP );
  139.  
  140.                      EndDialog( hdlg, bOptionsChanged );
  141.                      return TRUE;
  142.  
  143.                  case IDCANCEL:
  144.                      pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  145.                      hmem = pwoWorkOptions->hmem;
  146.                      LocalUnlock( hmem );
  147.                      LocalFree( hmem );
  148.                      RemoveProp( hdlg, OPTIONSPROP );
  149.  
  150.                      EndDialog( hdlg, FALSE  );
  151.                      return TRUE;
  152.  
  153.                  case EDIT_OPTIONS_SHOWMC:
  154.                      bChecked = IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SHOWMC );
  155.                      EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION_TEXT ),
  156.                                                                         bChecked );
  157.                      EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION ),
  158.                                                                         bChecked );
  159.                      return TRUE;
  160.  
  161.                  case EDIT_OPTIONS_COPYICON:
  162.                      bChecked = IsDlgButtonChecked( hdlg, EDIT_OPTIONS_COPYICON );
  163.                      EnableWindow( GetDlgItem( hdlg,
  164.                                           EDIT_OPTIONS_SHOWTITLEBAR ), bChecked );
  165.                      if( !bChecked )
  166.                          CheckDlgButton( hdlg, EDIT_OPTIONS_SHOWTITLEBAR, TRUE );
  167.                      return TRUE;
  168.  
  169.                  case EDIT_OPTIONS_SAVEASDEF:
  170.                      pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  171.                      GetCurrentDlgSettings( hdlg, pwoWorkOptions->lpOptions );
  172.                      SaveOptionsAsDefault( pwoWorkOptions->lpOptions );
  173.                      return TRUE;
  174.  
  175.                  case EDIT_OPTIONS_RESTRDEF:
  176.                      pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  177.                      PlayerGetDefaultOptions( pwoWorkOptions->lpOptions );
  178.                      SetDlgForOptions( hdlg, pwoWorkOptions->lpOptions );
  179.                      return FALSE;
  180.  
  181.                  default:
  182.                      return FALSE;
  183.                 }
  184.              return TRUE;
  185.  
  186.           default:
  187.              return FALSE;
  188.          }
  189.  
  190.       return FALSE;
  191.      }
  192.  
  193.  
  194. // Function: QTOLEServerCallBack - Server callback used by qtole.dll to
  195. //                                 send commands to the server
  196. // --------------------------------------------------------------------
  197. // Parameters: UINT                      uMessage
  198. //             WPARAM                    wParam
  199. //             LPARAM                    lParam
  200. //             LPQTOLE_OPTIONSMOVIE      lpOptions
  201. //
  202. //
  203. // Returns:    QTOLE_ERR        QTOLE_OK if OK
  204. // --------------------------------------------------------------------
  205.    QTOLE_ERR __export CALLBACK QTOLEServerCallBack
  206.                       ( UINT uMessage, WPARAM wParam, LPARAM lParam,
  207.                                             LPQTOLE_OPTIONSMOVIE lpOptions )
  208.  
  209.      {HWND           hwndMovie;
  210.       NPMOVIEDATA    pMovieData;
  211.       RECT           rcMovie;
  212.       RECT           rcClient;
  213.       RECT           rcIntersect;
  214.  
  215.  
  216.       switch( uMessage )
  217.          {case QTOLE_MSG_OPENOBJECT:
  218.                  // Open a movie window
  219.               SendMessage( PlayerQueryFrameWindow(),
  220.                                             WM_PLAYER_CMDLINE, 0, lParam );
  221.               hwndMovie = (HWND) SendMessage( PlayerQueryClientWindow(),
  222.                                                      WM_MDIGETACTIVE, 0, 0L );
  223.  
  224.               if( hwndMovie &&
  225.                        ( pMovieData = (NPMOVIEDATA) GetWindowWord( hwndMovie, 0 )))
  226.                  {pMovieData->qtoleOptions = *lpOptions;
  227.                   pMovieData->qtoleOptions.hwndObject = hwndMovie;
  228.                   pMovieData->qtoleOptions.mMovie     = pMovieData->mMovie;
  229.                   UpdateMovieForOptions( hwndMovie, pMovieData, TRUE );
  230.                  }
  231.  
  232.               break;
  233.  
  234.           case QTOLE_MSG_SHOWOBJECT:
  235.               hwndMovie = (HWND) wParam;
  236.  
  237.               ShowWindow( PlayerQueryFrameWindow(), SW_SHOWNORMAL );
  238.  
  239.               GetWindowRect( hwndMovie, &rcMovie );
  240.               MapWindowPoints( HWND_DESKTOP,
  241.                              PlayerQueryClientWindow(), (LPPOINT) &rcMovie, 2 );
  242.               GetClientRect( PlayerQueryClientWindow(), &rcClient );
  243.               if( !IntersectRect( &rcIntersect, &rcClient, &rcMovie ))
  244.                  {MoveWindow( hwndMovie, 0, 0,
  245.                                          rcMovie.right - rcMovie.left,
  246.                                          rcMovie.bottom - rcMovie.top, TRUE );
  247.                  }
  248.  
  249.               SendMessage( PlayerQueryClientWindow(),
  250.                                              WM_MDIACTIVATE, wParam, 0L );
  251.  
  252.               if( pMovieData = (NPMOVIEDATA) GetWindowWord( hwndMovie, 0 ))
  253.                  {pMovieData->qtoleOptions = *lpOptions;
  254.                   pMovieData->qtoleOptions.hwndObject = hwndMovie;
  255.                   pMovieData->qtoleOptions.mMovie     = pMovieData->mMovie;
  256.                   UpdateMovieForOptions( hwndMovie, pMovieData, TRUE );
  257.                 }
  258.  
  259.               break;
  260.  
  261.           case QTOLE_MSG_OPENOPTIONSDLG:
  262.              // Post message because we are not allowed to open a dialog
  263.              // inside an OLE method, in this case DoVerb which sends this message.
  264.              // In fact, opening the dialog directly seems to work but this
  265.              // is probably just lucky coincidence and can't be counted on.
  266.              // If wParam == hwndMovie is NULL, post to frame wnd because we don't
  267.              // open a movie wnd. If wParam != NULL, post message to hwndMovie to
  268.              // open the dialog
  269.  
  270.               if( NULL != ( hwndMovie = (HWND) wParam ))
  271.                  {PostMessage( hwndMovie, WM_COMMAND, PLAYER_EDIT_OPTIONS, 0L );
  272.                  }
  273.               else
  274.                  {PostMessage( PlayerQueryFrameWindow(),
  275.                                  WM_PLAYER_OLE_OPTIONSDLG, 0, (LPARAM) lpOptions );
  276.                  }
  277.  
  278.               break;
  279.  
  280.           case QTOLE_MSG_PLAYOBJECT:
  281.               PostMessage( PlayerQueryFrameWindow(),
  282.                                        WM_PLAYER_OLE_PLAYOBJECT, 0, lParam );
  283.               break;
  284.  
  285.           case QTOLE_MSG_FILEOPEN:
  286.               PostMessage( PlayerQueryFrameWindow(),
  287.                                            WM_COMMAND, PLAYER_FILE_OPEN, 0L );
  288.               break;
  289.  
  290.           default:
  291.               return QTOLE_GEN_ERROR;
  292.          }
  293.  
  294.       return QTOLE_OK;
  295.      }
  296.  
  297.  
  298. // Function: PlayerGetDefaultOptions - Gets the default options
  299. // --------------------------------------------------------------------
  300. // Parameters: LPQTOLE_OPTIONSMOVIE      lpOptions
  301. //
  302. // Returns:    VOID
  303. // --------------------------------------------------------------------
  304.    VOID FAR PlayerGetDefaultOptions( LPQTOLE_OPTIONSMOVIE lpOptions )
  305.  
  306.      {char      szSection[32];
  307.       char      szEntry[64];
  308.  
  309.      // Initial defaults
  310.    #define SHOWMC_DEF         TRUE
  311.    #define SELONLY_DEF        FALSE
  312.    #define DRAWFRAME_DEF      TRUE
  313.    #define USEPALETTE_DEF     TRUE
  314.    #define COPYICON_DEF       FALSE
  315.    #define SHOWTITLE_DEF      TRUE
  316.    #define CURRENTFRAME_DEF   TRUE
  317.    #define LOOP_DEF           FALSE
  318.    #define LOOPPALIND_DEF     FALSE
  319.    #define SIZEHALF_DEF       FALSE
  320.    #define SIZENORMAL_DEF     TRUE
  321.    #define SIZEDOUBLE_DEF     FALSE
  322.  
  323.       LoadString( PlayerQueryResources(),
  324.                     PLAYER_STRING_OPTIONS_NAME, szSection, sizeof( szSection ));
  325.  
  326.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  327.                     PLAYER_STRING_OPTIONS_SHOWMC, szEntry, sizeof( szEntry )))
  328.           lpOptions->bShowMovieController = SHOWMC_DEF;
  329.       else
  330.           lpOptions->bShowMovieController = (BOOL)
  331.                  GetPrivateProfileInt( szSection, szEntry, SHOWMC_DEF, QTW_PROFILE );
  332.  
  333.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  334.                  PLAYER_STRING_OPTIONS_PLAYSELONLY, szEntry, sizeof( szEntry )))
  335.           lpOptions->bPlaySelectionOnly = SELONLY_DEF;
  336.       else
  337.           lpOptions->bPlaySelectionOnly = (BOOL)
  338.                  GetPrivateProfileInt( szSection, szEntry, SELONLY_DEF, QTW_PROFILE );
  339.  
  340.       if( lpOptions->bSoundOnlyMovie )
  341.           lpOptions->bDrawWindowFrame = FALSE;
  342.       else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  343.                       PLAYER_STRING_OPTIONS_DRAWFRAME, szEntry, sizeof( szEntry )))
  344.           lpOptions->bDrawWindowFrame = DRAWFRAME_DEF;
  345.       else
  346.           lpOptions->bDrawWindowFrame = (BOOL)
  347.               GetPrivateProfileInt( szSection, szEntry, DRAWFRAME_DEF, QTW_PROFILE );
  348.  
  349.       if( lpOptions->bSoundOnlyMovie )
  350.           lpOptions->bUseMoviePalette = FALSE;
  351.       else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  352.                     PLAYER_STRING_OPTIONS_USEPALETTE, szEntry, sizeof( szEntry )))
  353.           lpOptions->bUseMoviePalette = USEPALETTE_DEF;
  354.       else
  355.           lpOptions->bUseMoviePalette = (BOOL)
  356.               GetPrivateProfileInt( szSection, szEntry, USEPALETTE_DEF, QTW_PROFILE );
  357.  
  358.  
  359.       if( lpOptions->bSoundOnlyMovie )
  360.           lpOptions->bCopyIcon = TRUE;
  361.       else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  362.                     PLAYER_STRING_OPTIONS_COPYICON, szEntry, sizeof( szEntry )))
  363.           lpOptions->bCopyIcon = COPYICON_DEF;
  364.       else
  365.           lpOptions->bCopyIcon = (BOOL)
  366.                  GetPrivateProfileInt( szSection, szEntry, COPYICON_DEF, QTW_PROFILE );
  367.  
  368.  
  369.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  370.                     PLAYER_STRING_OPTIONS_SHOWTITLE, szEntry, sizeof( szEntry )))
  371.           lpOptions->bShowTitleBar = SHOWTITLE_DEF;
  372.       else
  373.           lpOptions->bShowTitleBar = (BOOL)
  374.                 GetPrivateProfileInt( szSection, szEntry, SHOWTITLE_DEF, QTW_PROFILE );
  375.  
  376.  
  377.       if( lpOptions->bSoundOnlyMovie )            // This actually doesn't do anything
  378.           lpOptions->bCopyCurrentFrame = CURRENTFRAME_DEF;  // for sound only movies
  379.       else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  380.                     PLAYER_STRING_OPTIONS_CURRENTFRAME, szEntry, sizeof( szEntry )))
  381.           lpOptions->bCopyCurrentFrame = CURRENTFRAME_DEF;
  382.       else
  383.           lpOptions->bCopyCurrentFrame = (BOOL)
  384.               GetPrivateProfileInt( szSection, szEntry, CURRENTFRAME_DEF, QTW_PROFILE );
  385.  
  386.  
  387.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  388.                     PLAYER_STRING_OPTIONS_LOOP, szEntry, sizeof( szEntry )))
  389.           lpOptions->bLoop = LOOP_DEF;
  390.       else
  391.           lpOptions->bLoop = (BOOL)
  392.                   GetPrivateProfileInt( szSection, szEntry, LOOP_DEF, QTW_PROFILE );
  393.  
  394.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  395.                     PLAYER_STRING_OPTIONS_LOOPPALIND, szEntry, sizeof( szEntry )))
  396.           lpOptions->bLoopPalindrome = LOOPPALIND_DEF;
  397.       else
  398.           lpOptions->bLoopPalindrome = (BOOL)
  399.               GetPrivateProfileInt( szSection, szEntry, LOOPPALIND_DEF, QTW_PROFILE );
  400.  
  401.          // Now make sure only one option is on
  402.       if( lpOptions->bLoop )
  403.          {lpOptions->bLoopPalindrome = FALSE;
  404.          }
  405.  
  406.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  407.                    PLAYER_STRING_OPTIONS_SIZEHALF, szEntry, sizeof( szEntry )))
  408.           lpOptions->bSizeHalf = SIZEHALF_DEF;
  409.       else
  410.           lpOptions->bSizeHalf = (BOOL)
  411.                GetPrivateProfileInt( szSection, szEntry, SIZEHALF_DEF, QTW_PROFILE );
  412.  
  413.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  414.                    PLAYER_STRING_OPTIONS_SIZENORMAL, szEntry, sizeof( szEntry )))
  415.           lpOptions->bSizeNormal = SIZENORMAL_DEF;
  416.       else
  417.           lpOptions->bSizeNormal = (BOOL)
  418.                GetPrivateProfileInt( szSection, szEntry, SIZENORMAL_DEF, QTW_PROFILE );
  419.  
  420.       if( !szSection[0] || !LoadString( PlayerQueryResources(),
  421.                    PLAYER_STRING_OPTIONS_SIZEDOUBLE, szEntry, sizeof( szEntry )))
  422.           lpOptions->bSizeDouble = SIZEDOUBLE_DEF;
  423.       else
  424.           lpOptions->bSizeDouble = (BOOL)
  425.               GetPrivateProfileInt( szSection, szEntry, SIZEDOUBLE_DEF, QTW_PROFILE );
  426.  
  427.          // Now make sure no more than one option is on
  428.          // Give priority to normal
  429.       if( lpOptions->bSizeNormal )
  430.          {lpOptions->bSizeHalf   = FALSE;
  431.           lpOptions->bSizeDouble = FALSE;
  432.          }
  433.       else if( lpOptions->bSizeDouble )
  434.          {lpOptions->bSizeHalf = FALSE;
  435.          }
  436.  
  437.       return;
  438.      }
  439.  
  440.  
  441. // Function: SaveOptionsAsDefault - Caches the current options as the defaults
  442. //                                  in qtw.ini
  443. // --------------------------------------------------------------------
  444. // Parameters: LPQTOLE_OPTIONSMOVIE      lpOptions
  445. //
  446. // Returns:    VOID
  447. // --------------------------------------------------------------------
  448.    static VOID NEAR SaveOptionsAsDefault( LPQTOLE_OPTIONSMOVIE lpOptions )
  449.  
  450.      {char      szSection[32];
  451.       char      szEntry[64];
  452.  
  453.   #define szONE     "1"
  454.   #define szZERO    "0"
  455.  
  456.       if( !LoadString( PlayerQueryResources(),
  457.                     PLAYER_STRING_OPTIONS_NAME, szSection, sizeof( szSection )))
  458.           return;
  459.  
  460.       if( LoadString( PlayerQueryResources(),
  461.                     PLAYER_STRING_OPTIONS_SHOWMC, szEntry, sizeof( szEntry )))
  462.           WritePrivateProfileString( szSection, szEntry,
  463.                     lpOptions->bShowMovieController? szONE: szZERO, QTW_PROFILE );
  464.  
  465.       if( LoadString( PlayerQueryResources(),
  466.                  PLAYER_STRING_OPTIONS_PLAYSELONLY, szEntry, sizeof( szEntry )))
  467.           WritePrivateProfileString( szSection, szEntry,
  468.                        lpOptions->bPlaySelectionOnly? szONE: szZERO, QTW_PROFILE );
  469.  
  470.       if( !lpOptions->bSoundOnlyMovie )
  471.          {if( LoadString( PlayerQueryResources(),
  472.                     PLAYER_STRING_OPTIONS_DRAWFRAME, szEntry, sizeof( szEntry )))
  473.               WritePrivateProfileString( szSection, szEntry,
  474.                            lpOptions->bDrawWindowFrame? szONE: szZERO, QTW_PROFILE );
  475.  
  476.           if( LoadString( PlayerQueryResources(),
  477.                     PLAYER_STRING_OPTIONS_USEPALETTE, szEntry, sizeof( szEntry )))
  478.               WritePrivateProfileString( szSection, szEntry,
  479.                            lpOptions->bUseMoviePalette? szONE: szZERO, QTW_PROFILE );
  480.  
  481.           if( LoadString( PlayerQueryResources(),
  482.                     PLAYER_STRING_OPTIONS_COPYICON, szEntry, sizeof( szEntry )))
  483.               WritePrivateProfileString( szSection, szEntry,
  484.                            lpOptions->bCopyIcon? szONE: szZERO, QTW_PROFILE );
  485.          }
  486.  
  487.       if( LoadString( PlayerQueryResources(),
  488.                     PLAYER_STRING_OPTIONS_SHOWTITLE, szEntry, sizeof( szEntry )))
  489.           WritePrivateProfileString( szSection, szEntry,
  490.                            lpOptions->bShowTitleBar? szONE: szZERO, QTW_PROFILE );
  491.  
  492.       if( !lpOptions->bSoundOnlyMovie &&
  493.               LoadString( PlayerQueryResources(),
  494.                     PLAYER_STRING_OPTIONS_CURRENTFRAME, szEntry, sizeof( szEntry )))
  495.           WritePrivateProfileString( szSection, szEntry,
  496.                            lpOptions->bCopyCurrentFrame? szONE: szZERO, QTW_PROFILE );
  497.  
  498.  
  499.       if( LoadString( PlayerQueryResources(),
  500.                     PLAYER_STRING_OPTIONS_LOOP, szEntry, sizeof( szEntry )))
  501.           WritePrivateProfileString( szSection, szEntry,
  502.                            lpOptions->bLoop? szONE: szZERO, QTW_PROFILE );
  503.  
  504.       if( LoadString( PlayerQueryResources(),
  505.                     PLAYER_STRING_OPTIONS_LOOPPALIND, szEntry, sizeof( szEntry )))
  506.           WritePrivateProfileString( szSection, szEntry,
  507.                            lpOptions->bLoopPalindrome? szONE: szZERO, QTW_PROFILE );
  508.  
  509.       if( !lpOptions->bSoundOnlyMovie )
  510.          {if( LoadString( PlayerQueryResources(),
  511.                    PLAYER_STRING_OPTIONS_SIZEHALF, szEntry, sizeof( szEntry )))
  512.               WritePrivateProfileString( szSection, szEntry,
  513.                            lpOptions->bSizeHalf? szONE: szZERO, QTW_PROFILE );
  514.  
  515.           if( LoadString( PlayerQueryResources(),
  516.                    PLAYER_STRING_OPTIONS_SIZENORMAL, szEntry, sizeof( szEntry )))
  517.               WritePrivateProfileString( szSection, szEntry,
  518.                            lpOptions->bSizeNormal? szONE: szZERO, QTW_PROFILE );
  519.  
  520.           if( LoadString( PlayerQueryResources(),
  521.                    PLAYER_STRING_OPTIONS_SIZEDOUBLE, szEntry, sizeof( szEntry )))
  522.               WritePrivateProfileString( szSection, szEntry,
  523.                            lpOptions->bSizeDouble? szONE: szZERO, QTW_PROFILE );
  524.          }
  525.  
  526.       return;
  527.      }
  528.  
  529.  
  530. // Function: SetDlgForOptions - Sets the options dialog controls according
  531. //                              to current options
  532. // --------------------------------------------------------------------
  533. // Parameters: HWND                      hdlg
  534. //             LPQTOLE_OPTIONSMOVIE      lpOptions
  535. //
  536. //
  537. // Returns:    VOID
  538. // --------------------------------------------------------------------
  539.    static VOID NEAR SetDlgForOptions( HWND hdlg, LPQTOLE_OPTIONSMOVIE lpOptions )
  540.  
  541.      {BOOL      bCopyIcon;
  542.       int       idButton;
  543.  
  544.  
  545.       CheckDlgButton( hdlg, EDIT_OPTIONS_SHOWMC,
  546.                                           lpOptions->bShowMovieController );
  547.  
  548.       EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION_TEXT ),
  549.                                           lpOptions->bShowMovieController );
  550.       EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION ),
  551.                                           lpOptions->bShowMovieController );
  552.  
  553.       CheckDlgButton( hdlg, EDIT_OPTIONS_PLAYSELONLY,
  554.                                           lpOptions->bPlaySelectionOnly );
  555.       if( !lpOptions->bSoundOnlyMovie )
  556.          {CheckDlgButton( hdlg, EDIT_OPTIONS_DRAWFRAME,
  557.                                           lpOptions->bDrawWindowFrame );
  558.           CheckDlgButton( hdlg, EDIT_OPTIONS_USEPALETTE,
  559.                                           lpOptions->bUseMoviePalette );
  560.          }
  561.       else
  562.          {EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_DRAWFRAME ), FALSE );
  563.           EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_USEPALETTE ), FALSE );
  564.          }
  565.  
  566.  
  567.       if( !lpOptions->bSoundOnlyMovie )
  568.          {bCopyIcon = lpOptions->bCopyIcon;
  569.          }
  570.       else
  571.          {bCopyIcon = TRUE;
  572.           EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_COPYICON ), FALSE );
  573.          }
  574.  
  575.       CheckDlgButton( hdlg, EDIT_OPTIONS_COPYICON, bCopyIcon );
  576.       CheckDlgButton( hdlg, EDIT_OPTIONS_SHOWTITLEBAR, lpOptions->bShowTitleBar );
  577.       if( !bCopyIcon )
  578.           EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SHOWTITLEBAR ), FALSE );
  579.  
  580.  
  581.       if( !lpOptions->bSoundOnlyMovie )
  582.          {if( lpOptions->bCopyCurrentFrame )
  583.               idButton = EDIT_OPTIONS_COPYCURRENT;
  584.           else
  585.               idButton = EDIT_OPTIONS_COPYPOSTER;
  586.  
  587.           CheckRadioButton( hdlg, EDIT_OPTIONS_COPYCURRENT,
  588.                                           EDIT_OPTIONS_COPYPOSTER, idButton );
  589.          }
  590.       else
  591.          {EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_COPYCURRENT ), FALSE );
  592.           EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_COPYPOSTER ),  FALSE );
  593.          }
  594.  
  595.       if( lpOptions->bLoop )
  596.           idButton = EDIT_OPTIONS_LOOP;
  597.       else if( lpOptions->bLoopPalindrome )
  598.           idButton = EDIT_OPTIONS_PALINDROME;
  599.       else
  600.           idButton = EDIT_OPTIONS_STOPATEND;
  601.  
  602.       CheckRadioButton( hdlg, EDIT_OPTIONS_STOPATEND,
  603.                                           EDIT_OPTIONS_PALINDROME, idButton );
  604.  
  605.       if( !lpOptions->bSoundOnlyMovie )
  606.          {if( lpOptions->bSizeHalf )
  607.               idButton = EDIT_OPTIONS_SIZEHALF;
  608.           else if( lpOptions->bSizeNormal )
  609.               idButton = EDIT_OPTIONS_SIZENORMAL;
  610.           else if( lpOptions->bSizeDouble )
  611.               idButton = EDIT_OPTIONS_SIZEDOUBLE;
  612.           else
  613.               idButton = EDIT_OPTIONS_SIZECURRENT;
  614.  
  615.           CheckRadioButton( hdlg, EDIT_OPTIONS_SIZECURRENT,
  616.                                           EDIT_OPTIONS_SIZEDOUBLE, idButton );
  617.          }
  618.       else
  619.          {EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZECURRENT ), FALSE );
  620.           EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZEHALF ),    FALSE );
  621.           EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZENORMAL ),  FALSE );
  622.           EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZEDOUBLE ),  FALSE );
  623.           CheckRadioButton( hdlg, EDIT_OPTIONS_SIZECURRENT,
  624.                             EDIT_OPTIONS_SIZEDOUBLE, EDIT_OPTIONS_SIZECURRENT );
  625.          }
  626.  
  627.       return;
  628.      }
  629.  
  630.  
  631. // Function: GetCurrentDlgSettings - Fills the options struct with the current state
  632. //                                   of the dialog controls
  633. // --------------------------------------------------------------------
  634. // Parameters: HWND                      hdlg
  635. //             LPQTOLE_OPTIONSMOVIE      lpOptions
  636. //
  637. //
  638. // Returns:    VOID
  639. // --------------------------------------------------------------------
  640.    static VOID NEAR GetCurrentDlgSettings( HWND hdlg, LPQTOLE_OPTIONSMOVIE lpOptions )
  641.  
  642.      {lpOptions->bShowMovieController =
  643.                              IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SHOWMC );
  644.       GetDlgItemText( hdlg, EDIT_OPTIONS_CAPTION,
  645.                                     lpOptions->szCaption, MAX_TEXT_LEN );
  646.       lpOptions->bPlaySelectionOnly =
  647.                             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_PLAYSELONLY );
  648.  
  649.       if( !lpOptions->bSoundOnlyMovie )
  650.          {lpOptions->bDrawWindowFrame =
  651.                             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_DRAWFRAME );
  652.           lpOptions->bUseMoviePalette =
  653.                             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_USEPALETTE );
  654.  
  655.           lpOptions->bCopyIcon =
  656.                             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_COPYICON );
  657.           lpOptions->bShowTitleBar =
  658.                         IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SHOWTITLEBAR );
  659.          }
  660.       else
  661.          {lpOptions->bDrawWindowFrame = FALSE;
  662.           lpOptions->bUseMoviePalette = FALSE;
  663.           lpOptions->bCopyIcon        = TRUE;
  664.           lpOptions->bShowTitleBar    = IsDlgButtonChecked( hdlg,
  665.                                                      EDIT_OPTIONS_SHOWTITLEBAR );
  666.          }
  667.  
  668.       lpOptions->bLoop = IsDlgButtonChecked( hdlg, EDIT_OPTIONS_LOOP );
  669.       lpOptions->bLoopPalindrome =
  670.                          IsDlgButtonChecked( hdlg, EDIT_OPTIONS_PALINDROME );
  671.  
  672.       if( !lpOptions->bSoundOnlyMovie )
  673.          {lpOptions->bSizeHalf =
  674.                          IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SIZEHALF );
  675.           lpOptions->bSizeNormal =
  676.                          IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SIZENORMAL );
  677.           lpOptions->bSizeDouble =
  678.                          IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SIZEDOUBLE );
  679.  
  680.           lpOptions->bCopyCurrentFrame =
  681.                          IsDlgButtonChecked( hdlg, EDIT_OPTIONS_COPYCURRENT );
  682.          }
  683.       else
  684.          {lpOptions->bSizeHalf         = FALSE;
  685.           lpOptions->bSizeNormal       = FALSE;
  686.           lpOptions->bSizeDouble       = FALSE;
  687.           lpOptions->bCopyCurrentFrame = TRUE;
  688.          }
  689.  
  690.       return;
  691.      }
  692.